package com.mg.g2048.Data;

import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Random;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import android.graphics.PointF;

/**
 * 通用数据处理助手
 */
public class DataAssistant<E> {
	// 某个标点符号是否应该加到小段尾部
	private HashMap<String, Boolean> punctuationShouldAdd = null;
	// 回车符正则表达式
	private Pattern enterPattern = null;
	
	// 时间字符串格式（精确到分）
	private SimpleDateFormat simpleDateFormatMin = null;
	// 时间字符串格式（精确到秒）
	private SimpleDateFormat simpleDateFormatSec = null;
	// 时间字符串格式（精确到毫秒）
	private SimpleDateFormat simpleDateFormatMilli = null;
	// 时间字符串格式（仅时间部分，精确到分）
	private SimpleDateFormat simpleDateFormatOnlyTimeMin = null;
	// 替换当前日期的字符串（精确到年）
	private String yearReplaceStr = null;
	// 替换当前日期的字符串（精确到日）
	private String dayReplaceStr = null;

	
	public DataAssistant() {
		// 某个标点符号是否应该加到小段尾部
		punctuationShouldAdd = new HashMap<String, Boolean>();
		punctuationShouldAdd.put("，", true);
		punctuationShouldAdd.put("。", true);
		punctuationShouldAdd.put("（", false);
		punctuationShouldAdd.put("）", true);

		// 回车符正则表达式
		enterPattern = Pattern.compile("\r*\n+");
		
		// 时间字符串格式（精确到分）
		simpleDateFormatMin = new SimpleDateFormat("yyyy-MM-dd HH:mm");
		// 时间字符串格式（精确到秒）
		simpleDateFormatSec = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		// 时间字符串格式（精确到毫秒）
		simpleDateFormatMilli = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
		// 时间字符串格式（仅时间部分，精确到分）
		simpleDateFormatOnlyTimeMin = new SimpleDateFormat("HH:mm");
		
		Date date = new Date(System.currentTimeMillis());
		yearReplaceStr = (new SimpleDateFormat("yyyy-")).format(date);
		dayReplaceStr = (new SimpleDateFormat("yyyy-MM-dd ")).format(date);
	}

	/**
	 * 求一系列点到中心点的距离平均值
	 * 
	 * @param points
	 *            一系列点
	 * @param centerPoint
	 *            中心点
	 * @return 距离平均值
	 */
	public float getAvgDisToCenter(LinkedList<PointF> points, PointF centerPoint) {
		if (points == null || centerPoint == null)
			return 0;
		int totalCount = points.size();
		if (!(totalCount > 0))
			return 0;

		double totalDis = 0.0;
		for (PointF point : points)
			totalDis += Math.hypot((point.x - centerPoint.x), (point.y - centerPoint.y));

		return (float) (totalDis / totalCount);
	}

	/**
	 * 求一系列点的重心
	 */
	public PointF getBarycenter(LinkedList<PointF> points) {
		if (points == null)
			return null;
		int totalCount = points.size();
		if (!(totalCount > 0))
			return null;

		float totalX = 0;
		float totalY = 0;
		for (PointF point : points) {
			totalX += point.x;
			totalY += point.y;
		}

		return new PointF(totalX / totalCount, totalY / totalCount);
	}

	
	/**
	 * 计算相对目标尺寸时的缩放比例
	 * 
	 * @param srcWidth
	 *            源区域宽度
	 * @param srcHeight
	 *            源区域高度
	 * @param srcWidth
	 *            目标区域宽度
	 * @param srcHeight
	 *            目标区域高度
	 * @param isCropped
	 *            是否允许修剪
	 * @return 应该的缩放比例
	 */
	public float calcTgtScale(float srcWidth, float srcHeight, float tgtWidth, float tgtHeight, boolean isCropped) {
		return (float) calcTgtScale((double) srcWidth, srcHeight, tgtWidth, tgtHeight, isCropped);
	}

	/**
	 * 计算相对目标尺寸时的缩放比例
	 * 
	 * @param srcWidth
	 *            源区域宽度
	 * @param srcHeight
	 *            源区域高度
	 * @param srcWidth
	 *            目标区域宽度
	 * @param srcHeight
	 *            目标区域高度
	 * @param isCropped
	 *            是否允许修剪
	 * @return 应该的缩放比例
	 */
	public double calcTgtScale(double srcWidth, double srcHeight, double tgtWidth, double tgtHeight, boolean isCropped) {
		if (srcWidth <= 0 || srcHeight <= 0 || tgtWidth <= 0 || tgtHeight <= 0)
			return 1.0;

		// 宽度适应时的缩放比例
		double widthScale = tgtWidth / srcWidth;
		// 高度适应时的缩放比例
		double heightScale = tgtHeight / srcHeight;

		double resultScale = 1.0;
		// 允许修剪
		if (isCropped) {
			// 取较大的缩放比例值
			resultScale = Math.max(widthScale, heightScale);
		}
		// 不允许修剪
		else {
			// 取较小的缩放比例值
			resultScale = Math.min(widthScale, heightScale);
		}

		return resultScale;
	}

	/**
	 * 保留n位小数
	 */
	public float retainNdecimal(float value, int n) {
		return (float) retainNdecimal((double) value, n);
	}

	/**
	 * 保留n位小数
	 */
	public double retainNdecimal(double value, int n) {
		double result = 0.0;

		String formatStr = "#0.";
		for (int i = 0; i < n; i++)
			formatStr += "0";
		DecimalFormat decimalFormat = new DecimalFormat(formatStr);
		result = Double.valueOf(decimalFormat.format(value));

		return result;
	}
	
	/**
	 * 在字符串指定位置处添加空格
	 * 
	 * @param str
	 *            待处理字符串
	 * @param indexArray
	 *            位置索引数组（从0开始，最后一位索引不得大于待处理字符串长度）
	 * @return 结果字符串
	 */
	public String addSpaceAtIndex(String str, int[] indexArray){
		return addStrAtIndex(str, " ", indexArray);
	}
	
	/**
	 * 在字符串指定位置处添加一段内容
	 * 
	 * @param str
	 *            待处理字符串
	 * @param addedStr
	 *            被添加内容
	 * @param indexArray
	 *            位置索引数组（从0开始，最后一位索引不得大于待处理字符串长度）
	 * @return 结果字符串
	 */
	public String addStrAtIndex(String str, String addedStr, int[] indexArray){
		if(str == null || indexArray == null)
			return null;
		
		int strLength = str.length();
		int indexArrayLength = indexArray.length;
		String resultStr = "";
		
		for (int i=0; i<indexArrayLength - 1; i++){
			// 如果字符串长度小于最后索引的长度
			if(strLength < indexArray[i+1]){
				if(strLength > indexArray[i] && strLength <= indexArray[i+1])
					resultStr += str.substring(indexArray[i], strLength);
				break;
			}
			resultStr += str.substring(indexArray[i], indexArray[i+1]);
			resultStr += addedStr;
		}
		// 连接最后几个字符
		if(indexArray[indexArrayLength - 1] < strLength)
			resultStr += str.substring(indexArray[indexArrayLength - 1], strLength);
		
		return resultStr;
	}
	
	/**
	 * 处理变量后面的0
	 * @param f 浮点型变量
	 * @return 处理完的字符串
	 */
	public String getSmartStringFromDecimal(float f){
		String str = String.valueOf(f);
		
		// 去掉末尾连续的0
		Pattern p = Pattern.compile("(\\.[^0]*)0+$");
		Matcher m = p.matcher(str);
		str = m.replaceFirst("$1");
		// 去掉末尾的小数点
		str = str.replaceFirst("\\.$", "");
		
		return str;
	}

	/**
	 * 处理变量后面的0
	 * @param d 双精度型变量
	 * @return 处理完的字符串
	 */
	public String getSmartStringFromDecimal(double d){
		String str = String.valueOf(d);
		
		// 去掉末尾连续的0
		Pattern p = Pattern.compile("(\\.[^0]*)0+$");
		Matcher m = p.matcher(str);
		str = m.replaceFirst("$1");
		// 去掉末尾的小数点
		str = str.replaceFirst("\\.$", "");
		
		return str;
	}
	
	/**
	 * 生成随机整数数组
	 * 
	 * @param max
	 *            最大值
	 * @param count
	 *            个数，0 < count <= max
	 * @return 随机整数数组，每个均小于max
	 */
	public int[] genRandomIntArray(int max, int count) {
		if (max < 1)
			return null;
		if (count < 1 || count > max)
			return null;
		
		int[] intArray = new int[count];
		int half = max >> 1;
		boolean reverse = false;
		int tempCount = 0;
		HashSet<Integer> tempSet = new HashSet<Integer>();
		
		if (count < half) {
			reverse = false;
			tempCount = count;
		} else {
			reverse = true;
			tempCount = max - count;
		}
		
		int generated = 0;
		int tempInt = 0;
		Random random = new Random(System.currentTimeMillis());
		while (generated < tempCount) {
			tempInt = random.nextInt(max);
			
			if (tempSet.add(tempInt))
				++generated;
		}
		
		int j = 0;
		for (int i = 0; i < max; i++) {
			if (!(reverse ^ tempSet.contains(i)))
				continue;
				
			if (j < count) {
				intArray[j] = i;
				++j;
			} else {
				break;
			}
		}
		
		return intArray;
	}
	
	/**
	 * 随机排列某类型的LinkedList
	 * 
	 * @param list
	 *            某类型的LinkedList
	 */
	public void genRandomLinkedList(LinkedList<E> list) {
		if (list == null)
			return;

		// 个数
		int count = list.size();
		// 以 当前时间毫秒数 为种子的随机数生成器
		Random random = new Random(System.currentTimeMillis());
		// 随机数索引
		int index = 0;
		// 临时对象
		E obj = null;

		for (int i = 0; i < count; i++) {
			// 随机数索引
			index = random.nextInt(count);

			// 指向对象不一样
			if (index != i) {
				// 交换对象
				obj = list.get(i);
				list.set(i, list.get(index));
				list.set(index, obj);
			}
		}
	}

	/**
	 * 对字符串链表升序排列
	 * 
	 * @param inList
	 *            字符串链表
	 * @return 升序排列的链表
	 */
	public LinkedList<String> getSortedStringListFromList(LinkedList<String> inList) {
		if (inList == null)
			return null;
		if (inList.isEmpty())
			return null;

		// 与字符串链表等长
		String[] strArray = new String[inList.size()];
		// 将字符串链表数据转移到数组中
		inList.toArray(strArray);
		// 排序
		Arrays.sort(strArray);
		
		LinkedList<String> outList = new LinkedList<String>();
		for (String str : strArray)
			outList.add(str);

		return outList;
	}

	/**
	 * 由字符串集合得到升序排列的链表
	 * 
	 * @param intSet
	 *            字符串集合
	 * @return 升序排列的链表
	 */
	public LinkedList<String> getSortedStringListFromSet(Set<String> inSet) {
		if (inSet == null)
			return null;
		if (inSet.isEmpty())
			return null;

		// 与字符串集合等长
		String[] strArray = new String[inSet.size()];
		// 将字符串集合数据转移到数组中
		inSet.toArray(strArray);
		// 排序
		Arrays.sort(strArray);
		
		LinkedList<String> strList = new LinkedList<String>();
		for (String str : strArray)
			strList.add(str);

		return strList;
	}

	/**
	 * 由整数集合得到升序排列的数组
	 * 
	 * @param intSet
	 *            整数集合
	 * @return 升序排列的数组
	 */
	public Integer[] getSortedIntegerFromSet(Set<Integer> intSet) {
		if (intSet == null)
			return null;
		if (intSet.isEmpty())
			return null;

		// 与整数集合等长
		Integer[] intArray = new Integer[intSet.size()];
		// 将整数集合数据转移到数组中
		intSet.toArray(intArray);
		// 排序
		Arrays.sort(intArray);

		return intArray;
	}

	/**
	 * 对字符串每个字符进行排序
	 * 
	 * @param str
	 *            字符串
	 * @return 每个字符排序后的字符串
	 */
	public String sortEveryCharOfString(String str) {
		if (str == null)
			return null;
		int length = str.length();
		if (length == 0)
			return null;
		
		String tempStr = null;
		LinkedList<String> tempList = new LinkedList<String>();
		for (int i = 0; i < length; i++) {
			tempStr = str.substring(i, i + 1);
			tempList.addLast(tempStr);
		}
		// 升序排列
		tempList = getSortedStringListFromList(tempList);
		if (tempList == null)
			return null;
		if (tempList.isEmpty())
			return null;
		
		String resultStr = "";
		for (String s : tempList)
			resultStr += s;
		
		return resultStr;
	}

	/**
	 * 将字符串链表各元素连接起来
	 * 
	 * @param list
	 *            字符串链表
	 * @param separator
	 *            分隔符
	 * @return 连接后的字符串
	 */
	public String joinStringList(LinkedList<String> list, String separator) {
		if (list == null || separator == null)
			return null;
		if (list.isEmpty())
			return null;
		
		String resultStr = null;
		boolean isFirst = true;
		for (String s : list) {
			if (isFirst) {
				resultStr = s;
				isFirst = false;
			} else {
				resultStr += (separator + s);
			}
		}
		
		return resultStr;
	}
	
	/**
	 * 将字符串数组各元素连接起来
	 * 
	 * @param array
	 *            字符串数组
	 * @param separator
	 *            分隔符
	 * @return 连接后的字符串
	 */
	public String joinStringArray(String[] array, String separator) {
		if (array == null || separator == null)
			return null;
		if (array.length == 0)
			return null;
		
		String resultStr = null;
		boolean isFirst = true;
		for (String s : array) {
			if (isFirst) {
				resultStr = s;
				isFirst = false;
			} else {
				resultStr += (separator + s);
			}
		}
		
		return resultStr;
	}

	
	/**
	 * 将距离数值转换为距离字符串（智能化处理）
	 * 
	 * @param distance
	 *            距离数值（以米为单位）
	 * @return 距离字符串
	 */
	public String getSmartDistenceStrFromMeter(float distance) {
		BigDecimal bd = null;
		float f = 0;
		
		if(distance >= 1000){
			if(distance < 1100)
				return "1千米";
			bd = new BigDecimal(distance / 1000); 
			f = bd.setScale(1, BigDecimal.ROUND_HALF_UP).floatValue(); 
			return f + "千米";
		}
		
		return (int)f + "米";
	}

	/**
	 * 将 时间字符串（仅时间部分，精确到分） 转换为 毫秒数
	 */
	public long getTimeMillisFromShortTimeStrOnlyTime(String timeStr) {
		Date date = null;
		try {
			date = simpleDateFormatOnlyTimeMin.parse(timeStr);
		} catch (ParseException e) {
			e.printStackTrace();
		}

		if (date == null)
			return 0L;

		return date.getTime();
	}
	
	/**
	 * 将 时间字符串（精确到毫秒） 转换为 毫秒数
	 */
	public long getTimeMillisFromLongTimeStr(String timeStr) {
		Date date = null;
		try {
			date = simpleDateFormatMilli.parse(timeStr);
		} catch (ParseException e) {
			e.printStackTrace();
		}

		if (date == null)
			return 0L;

		return date.getTime();
	}

	/**
	 * 将 时间字符串（精确到秒） 转换为 毫秒数
	 */
	public long getTimeMillisFromTimeStr(String timeStr) {
		Date date = null;
		try {
			date = simpleDateFormatSec.parse(timeStr);
		} catch (ParseException e) {
			e.printStackTrace();
		}

		if (date == null)
			return 0L;

		return date.getTime();
	}

	/**
	 * 将 时间字符串（精确到分） 转换为 毫秒数
	 */
	public long getTimeMillisFromShortTimeStr(String timeStr) {
		Date date = null;
		try {
			date = simpleDateFormatMin.parse(timeStr);
		} catch (ParseException e) {
			e.printStackTrace();
		}

		if (date == null)
			return 0L;

		return date.getTime();
	}

	/**
	 * 将 毫秒数 转换为 时间字符串（智能化处理）
	 * 
	 * @param withSec
	 *            是否显示秒数
	 */
	public String getSmartTimeStrFromTimeMillis(long timeMillis, boolean withSec) {
		String srcTimeStr = null;
		// 显示秒数
		if (withSec)
			srcTimeStr = getTimeStrFromTimeMillis(timeMillis);
		// 不显示秒数
		else
			srcTimeStr = getShortTimeStrFromTimeMillis(timeMillis);
		if (srcTimeStr == null)
			return null;
		
		String tgtTimeStr = null;
		// 同一天相同部分
		if (dayReplaceStr != null)
			tgtTimeStr = srcTimeStr.replace(dayReplaceStr, "");
		if (tgtTimeStr == null)
			return null;
		
		// 同一年相同部分
		if (yearReplaceStr != null)
			tgtTimeStr = tgtTimeStr.replace(yearReplaceStr, "");
		
		return tgtTimeStr;
	}

	/**
	 * 将 毫秒数 转换为 时间字符串（仅时间部分，精确到分）
	 */
	public String getShortTimeStrOnlyTimeFromTimeMillis(long timeMillis) {
		Date date = new Date(timeMillis);
		return simpleDateFormatOnlyTimeMin.format(date);
	}

	/**
	 * 将 毫秒数 转换为 时间字符串（精确到毫秒）
	 */
	public String getLongTimeStrFromTimeMillis(long timeMillis) {
		Date date = new Date(timeMillis);
		return simpleDateFormatMilli.format(date);
	}

	/**
	 * 将 毫秒数 转换为 时间字符串（精确到秒）
	 */
	public String getTimeStrFromTimeMillis(long timeMillis) {
		Date date = new Date(timeMillis);
		return simpleDateFormatSec.format(date);
	}
	
	/**
	* 将 毫秒数 转换为 时间字符串（精确到秒）
	*/
	public String getTimeStrFromTimeMillis(Date date) {
		return simpleDateFormatSec.format(date);
	}

	/**
	 * 将 毫秒数 转换为 时间字符串（精确到分）
	 */
	public String getShortTimeStrFromTimeMillis(long timeMillis) {
		Date date = new Date(timeMillis);
		return simpleDateFormatMin.format(date);
	}

	
	/**
	 * 将一个字符串从标点符号处分割，得到每段都不超过指定长度的小串
	 * 
	 * @param str
	 *            原字符串
	 * @param maxLength
	 *            每小段的最大长度
	 * @return 含各小段数据的LinkedList
	 */
	public LinkedList<String> splitStrToListByCertainLengthAndPunctuation(String str, int maxLength) {
		if (str == null)
			return null;

		// 去掉字符串中的回车符
		str = removeEntersFromStr(str);

		// ========== 先按标点符号分小段 ==========
		// 由标点符号分割后的小串链表
		LinkedList<String> segmentsSplitedByPunctuation = new LinkedList<String>();
		// 原字符串长度
		int strLength = str.length();
		// 当前字符
		String currentChar = "";
		// 当前处理的小段开始字符的索引
		int startIndex = 0;
		for (int i = 0; i < strLength; i++) {
			currentChar = str.substring(i, i + 1);
			// 不是标点，则看下一个
			if (!punctuationShouldAdd.containsKey(currentChar))
				continue;

			// 该标点符号应该加到小段尾部
			if (punctuationShouldAdd.get(currentChar)) {
				segmentsSplitedByPunctuation.add(str.substring(startIndex, i + 1));
				startIndex = i + 1;
			}
			// 不应该加到小段尾部
			else {
				segmentsSplitedByPunctuation.add(str.substring(startIndex, i));
				startIndex = i;
			}
		}

		// 最后一个字符不是标点，需要单独添加最后一小段
		if (strLength > 0 && !punctuationShouldAdd.containsKey(str.substring(strLength - 1, strLength))) {
			segmentsSplitedByPunctuation.add(str.substring(startIndex, strLength));
		}

		// ========== 再将一些特别长的小段分割为多段 ==========
		// 每段都不超过最大长度的小串链表
		LinkedList<String> segmentsSplitedByCertainLength = new LinkedList<String>();
		// 临时小串链表
		LinkedList<String> tempSegments = null;
		for (String segment : segmentsSplitedByPunctuation) {
			// 该小段过长
			if (segment.length() > maxLength) {
				// 将其分割为每段都不超过最大长度的小串
				tempSegments = splitStrToListByCertainLength(segment, maxLength);

				if (tempSegments != null) {
					for (String tempSegment : tempSegments) {
						// 添加到链表
						segmentsSplitedByCertainLength.add(tempSegment);
					}
				}
			}
			// 小段未超长
			else {
				// 直接添加
				segmentsSplitedByCertainLength.add(segment);
			}
		}

		// ========== 最后合并一些小段 ==========
		// 小段个数
		int segmentCount = segmentsSplitedByCertainLength.size();
		// 不只一段才有合并必要
		if (segmentCount > 1) {
			for (int i = 1; i < segmentCount;) {
				// 相邻两段合并后长度过长的话，不合并，进入下一段
				if (segmentsSplitedByCertainLength.get(i - 1).length() + segmentsSplitedByCertainLength.get(i).length() > maxLength) {
					i++;
					continue;
				}

				// 将该两段合并
				segmentsSplitedByCertainLength.set(i - 1, (segmentsSplitedByCertainLength.get(i - 1) + segmentsSplitedByCertainLength.get(i)));
				// 删除后段数据
				segmentsSplitedByCertainLength.remove(i);
				// 段数减少1个
				--segmentCount;
			}
		}

		return segmentsSplitedByCertainLength;
	}

	/**
	 * 将一个字符串分割为每段都不超过指定长度的小串
	 * 
	 * @param str
	 *            原字符串
	 * @param maxLength
	 *            每小段的最大长度
	 * @return 含各小段数据的LinkedList
	 */
	public LinkedList<String> splitStrToListByCertainLength(String str, int maxLength) {
		if (str == null)
			return null;

		// 小串链表
		LinkedList<String> list = new LinkedList<String>();
		// 长度
		int strLength = str.length();
		if (strLength > 0) {
			// 小段结束后的字符索引
			int end = 0;
			for (int i = 0; i < strLength;) {
				// 满长
				end = i + maxLength;
				// 不能满长
				if (strLength < end)
					end = strLength;

				// 将小串加入链表
				list.add(str.substring(i, end));
				i = end;
			}
		} else {
			// 一个空字符串
			list.add(new String(""));
		}

		return list;
	}

	/**
	 * 为一条文字各个段落前加上一段空白
	 * 
	 * @param str
	 *            待处理文字
	 * @param spaceStr
	 *            段落前空白
	 * @retrurn 处理好的文字
	 */
	public String addHeaderSpaceForParagraph(String str, String spaceStr) {
		String resultStr = "";

		// 所有段尾加空白（效果是后面的段首加了空白，第一段除外，最后一段有"\n"也会被加空白）
		resultStr = str.replace("\n", "\n" + spaceStr);
		// 去掉首尾空白
		resultStr = resultStr.trim();
		// 整条文字，即第一段段首加空白
		resultStr = spaceStr + resultStr;

		return resultStr;
	}

	public void setPunctuationShouldAdd(HashMap<String, Boolean> punctuationShouldAdd) {
		this.punctuationShouldAdd = punctuationShouldAdd;
	}
	
	/**
	 * 替换一组字符串
	 * 
	 * @param str
	 *            待处理字符串
	 * @param oldStrArray
	 *            原字符串的数组
	 * @param newStrArray
	 *            新字符串的数组
	 * @return 替换后的字符串
	 */
	public String replaceAGroupStr(String str, String[] oldStrArray, String[] newStrArray) {
		if (str == null || oldStrArray == null || newStrArray == null)
			return null;
		if (oldStrArray.length != newStrArray.length)
			return null;
		
		String resultStr = new String(str);
		for (int i = 0; i < oldStrArray.length; i++)
			resultStr = resultStr.replaceAll(oldStrArray[i], newStrArray[i]);
		
		return resultStr;
	}

	/**
	 * 去掉字符串中的回车符
	 * 
	 * @param str
	 *            待处理字符串
	 * @return 去掉回车符后的字符串
	 */
	public String removeEntersFromStr(String str) {
		if (str == null)
			return null;

		Matcher matcher = enterPattern.matcher(str);
		// 替换为空
		return matcher.replaceAll("");
	}


	/**
	 * 求一系列点的重心
	 */
	public PointF getBarycenter(ArrayList<PointF> points) {
		if (points == null)
			return null;
		int totalCount = points.size();
		if (!(totalCount > 0))
			return null;

		float totalX = 0;
		float totalY = 0;
		for (PointF point : points) {
			totalX += point.x;
			totalY += point.y;
		}

		return new PointF(totalX / totalCount, totalY / totalCount);
	}
	
	/**
	 * 求一系列点到中心点的距离平均值
	 * 
	 * @param points 一系列点
	 * 
	 * @param centerPoint 中心点
	 * 
	 * @return 距离平均值
	 */
	public float getAvgDisToCenter(ArrayList<PointF> points, PointF centerPoint) {
		if (points == null || centerPoint == null)
			return 0;
		int totalCount = points.size();
		if (!(totalCount > 0))
			return 0;

		double totalDis = 0.0;
		for (PointF point : points)
			totalDis += Math.hypot((point.x - centerPoint.x), (point.y - centerPoint.y));

		return (float) (totalDis / totalCount);
	}
}
